YES 0.743 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/Monad.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ LR

mainModule Monad
  ((mapAndUnzipM :: (a  ->  IO (b,c))  ->  [a ->  IO ([b],[c])) :: (a  ->  IO (b,c))  ->  [a ->  IO ([b],[c]))

module Monad where
  import qualified Maybe
import qualified Prelude

  mapAndUnzipM :: Monad c => (d  ->  c (b,a))  ->  [d ->  c ([b],[a])
mapAndUnzipM f xs sequence (map f xs>>= return . unzip


module Maybe where
  import qualified Monad
import qualified Prelude



Lambda Reductions:
The following Lambda expression
\xsreturn (x : xs)

is transformed to
sequence0 x xs = return (x : xs)

The following Lambda expression
\xsequence cs >>= sequence0 x

is transformed to
sequence1 cs x = sequence cs >>= sequence0 x

The following Lambda expression
\(a,b)~(as,bs)→(a : as,b : bs)

is transformed to
unzip0 (a,b) ~(as,bs) = (a : as,b : bs)



↳ HASKELL
  ↳ LR
HASKELL
      ↳ IPR

mainModule Monad
  ((mapAndUnzipM :: (b  ->  IO (c,a))  ->  [b ->  IO ([c],[a])) :: (b  ->  IO (c,a))  ->  [b ->  IO ([c],[a]))

module Maybe where
  import qualified Monad
import qualified Prelude


module Monad where
  import qualified Maybe
import qualified Prelude

  mapAndUnzipM :: Monad d => (b  ->  d (c,a))  ->  [b ->  d ([c],[a])
mapAndUnzipM f xs sequence (map f xs>>= return . unzip



IrrPat Reductions:
The variables of the following irrefutable Pattern
~(as,bs)

are replaced by calls to these functions
unzip00 (as,bs) = as

unzip01 (as,bs) = bs



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IPR
HASKELL
          ↳ BR

mainModule Monad
  ((mapAndUnzipM :: (b  ->  IO (a,c))  ->  [b ->  IO ([a],[c])) :: (b  ->  IO (a,c))  ->  [b ->  IO ([a],[c]))

module Monad where
  import qualified Maybe
import qualified Prelude

  mapAndUnzipM :: Monad c => (a  ->  c (b,d))  ->  [a ->  c ([b],[d])
mapAndUnzipM f xs sequence (map f xs>>= return . unzip


module Maybe where
  import qualified Monad
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IPR
        ↳ HASKELL
          ↳ BR
HASKELL
              ↳ COR

mainModule Monad
  ((mapAndUnzipM :: (c  ->  IO (b,a))  ->  [c ->  IO ([b],[a])) :: (c  ->  IO (b,a))  ->  [c ->  IO ([b],[a]))

module Maybe where
  import qualified Monad
import qualified Prelude


module Monad where
  import qualified Maybe
import qualified Prelude

  mapAndUnzipM :: Monad b => (d  ->  b (a,c))  ->  [d ->  b ([a],[c])
mapAndUnzipM f xs sequence (map f xs>>= return . unzip



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IPR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
HASKELL
                  ↳ Narrow

mainModule Monad
  (mapAndUnzipM :: (a  ->  IO (b,c))  ->  [a ->  IO ([b],[c]))

module Monad where
  import qualified Maybe
import qualified Prelude

  mapAndUnzipM :: Monad c => (a  ->  c (b,d))  ->  [a ->  c ([b],[d])
mapAndUnzipM f xs sequence (map f xs>>= return . unzip


module Maybe where
  import qualified Monad
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IPR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_foldr(:(vz50, vz51), h, ba) → new_foldr(vz51, h, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IPR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
QDP
                        ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

new_sequence1(vz3, vz41, vz6, h, ba, bb) → new_sequence(vz3, vz41, h, ba, bb)
new_sequence(vz3, :(vz40, vz41), h, ba, bb) → new_sequence(vz3, vz41, h, ba, bb)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IPR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                        ↳ DependencyGraphProof
QDP
                            ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_sequence(vz3, :(vz40, vz41), h, ba, bb) → new_sequence(vz3, vz41, h, ba, bb)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: